import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2023-02-08
 * Time: 18:28
 */

// 创建一个类 Result , 包含一个 sum 表示最终结果, lock 表示线程同步使用的锁对象
class Result {
    public int sum = 0;
    public Object lock = new Object();
}


public class Thread_Demo25 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        /*Result result = new Result();
        Thread t = new Thread() {
            @Override
            public void run() {
                int ret = 0;
                for (int i = 1; i <= 1000; i++) {
                    ret += i;
                }

                synchronized (result.lock) {
                    // 将结果赋值给sum
                    result.sum = ret;
                    result.lock.notify();
                }
            }
        };

        t.start();

        // 主线程阻塞等待t线程计算完毕
        synchronized (result.lock) {
            while(result.sum == 0) {
                // 如果执行到wait之前 t线程以及计算结束 不需要在等待
                result.lock.wait();
            }
            System.out.println(result.sum);
        }*/


        // 使用 Callable 版本
        Callable<Integer> callable = new Callable<Integer>() {
            // 从写Calable的call方法 需要确定返回值
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= 1000; i++) {
                    sum += i;
                }
                return sum; // Callable 带有泛型参数, 泛型参数类型代表返回值类型
            }
        };

        // FutureTask实现了RunnableFuture接口
        FutureTask<Integer> futureTask = new FutureTask<>(callable); // 包装Callable 实例
        // 通过线程的构造方法将FutureTask实例传入创建线程
        Thread t = new Thread(futureTask); // 调用futuretask中的call方法完成计算

        t.start();

        int result = futureTask.get(); // 等待计算结果并返回结果
        System.out.println(result);
    }

}
